#include "uart_origin.hpp"
#include <thread>
#include <chrono>
#include <iostream>
#include <iomanip>

#include <glog/logging.h>

// void test_thread()
// {
//     uart_v3 port("/dev/ttyS1", 115200, 8, 1, 0); // 8N1配置
//     int received;
//     uint8_t data[] = {0x3E, 0xA4, 0x01, 0x0C, 0xEF, 0xD0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x27, 0x00, 0x00, 0x0E};
//     uint8_t buf[128];
//     port.open();
//     while (1)
//     {
//         try
//         {
            

//             port.send(data, sizeof(data));

//             memset(buf, 0, sizeof(buf));
//             int received = port.receive(buf, sizeof(buf));
//         }
//         catch (const std::system_error &e)
//         {
//             std::cerr << "Error: " << e.what() << std::endl;
//         }
//         std::cout << "Received " << received << " bytes: ";
//         for (int i = 0; i < received; ++i)
//         {
//             std::cout << "buf[" << i << "] = ";
//             std::cout << std::hex << std::setw(2) << std::setfill('0') << (int)buf[i] << " ";
//         }
//         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
//     }
// }
// int main(int argc, char *argv[])
// {
//     std::thread t1(test_thread);

//     std::cin.get();
//     t1.join();
//     return 0;
// }

// #include "main.hpp"
// #include <iostream>
// #include <iomanip>
// #include <thread>
// #include <csignal>
// #include <string>
// #include <vector>
// #include <cstring>

// volatile sig_atomic_t g_running = 1;

// void signal_handler(int sig)
// {
//     g_running = 0;
// }

// void printHexData(const std::vector<uint8_t> &data)
// {
//     std::cout << "Received data (" << data.size() << " bytes): ";
//     for (const auto &byte : data)
//     {
//         std::cout << std::hex << std::setw(2) << std::setfill('0')
//                   << static_cast<int>(byte) << " ";
//     }
//     std::cout << std::dec << std::endl;
// }

// int main(int argc, char *argv[])
// {
//     signal(SIGINT, signal_handler);
//     signal(SIGTERM, signal_handler);

//     if (argc < 4)
//     {
//         std::cerr << "Usage: " << argv[0]
//                   << " <device_path> <gpio_chip> <de_pin_offset> [baud_rate]" << std::endl;
//         std::cerr << "Example: " << argv[0]
//                   << " /dev/ttyS1 gpiochip0 158 115200" << std::endl;
//         return 1;
//     }

//     std::string devicePath = argv[1];
//     std::string gpioChip = argv[2];
//     unsigned int dePinOffset = std::stoi(argv[3]);
//     int baudRate = (argc > 4) ? std::stoi(argv[4]) : 9600;

//     std::cout << "Opening RS485 device: " << devicePath << std::endl;
//     std::cout << "Using GPIO chip: " << gpioChip << std::endl;
//     std::cout << "Using DE/RE pin offset: " << dePinOffset << std::endl;
//     std::cout << "Baud rate: " << baudRate << std::endl;

//     auto start = std::chrono::steady_clock::now();

//     RS485Module rs485(devicePath, gpioChip, dePinOffset);

//     // 配置串口参数
//     switch (baudRate)
//     {
//     case 1200:
//         rs485.setBaudRate(RS485Module::BaudRate::BAUD_1200);
//         break;
//     case 2400:
//         rs485.setBaudRate(RS485Module::BaudRate::BAUD_2400);
//         break;
//     case 4800:
//         rs485.setBaudRate(RS485Module::BaudRate::BAUD_4800);
//         break;
//     case 9600:
//         rs485.setBaudRate(RS485Module::BaudRate::BAUD_9600);
//         break;
//     case 19200:
//         rs485.setBaudRate(RS485Module::BaudRate::BAUD_19200);
//         break;
//     case 38400:
//         rs485.setBaudRate(RS485Module::BaudRate::BAUD_38400);
//         break;
//     case 57600:
//         rs485.setBaudRate(RS485Module::BaudRate::BAUD_57600);
//         break;
//     case 115200:
//         rs485.setBaudRate(RS485Module::BaudRate::BAUD_115200);
//         break;
//     default:
//         std::cerr << "Unsupported baud rate: " << baudRate << std::endl;
//         return 1;
//     }

//     rs485.setDataBits(RS485Module::DataBits::DATA_8);
//     rs485.setStopBits(RS485Module::StopBits::STOP_1);
//     rs485.setParity(RS485Module::Parity::NONE);
//     rs485.setFlowControl(RS485Module::FlowControl::NONE);
//     rs485.setReadTimeout(1000);
//     rs485.setWriteTimeout(1000);

//     // 设置接收回调函数
//     rs485.setReceiveCallback(printHexData);

//     std::cout << "Attempting to open device..." << std::endl;

//     // 打开设备
//     if (!rs485.open())
//     {
//         std::cerr << "Failed to open device: " << rs485.getLastError() << std::endl;
//         return 1;
//     }

//     std::cout << "RS485Module config is " << std::endl;
//     rs485.printSerialSettings();

//     auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start).count();

//     if (elapsed > 2000)
//     {
//         std::cout << "Warning: Device initialization took " << elapsed << "ms" << std::endl;
//     }

//     // 启动异步接收线程
//     std::cout << "Starting async receive thread..." << std::endl;
//     if (!rs485.startAsyncReceive())
//     {
//         std::cerr << "Failed to start async receive: " << rs485.getLastError() << std::endl;
//         rs485.close();
//         return 1;
//     }

//     std::cout << "RS485 device opened successfully" << std::endl;
//     std::cout << "Press Ctrl+C to exit" << std::endl;
//     std::cout << "Enter data to send (hex format, e.g. 01 02 03): " << std::endl;

//     std::string input;
//     while (g_running)
//     {
//         std::cout << "> ";
//         std::getline(std::cin, input);

//         if (!g_running)
//             break;

//         if (input.empty())
//         {
//             continue;
//         }

//         // 解析十六进制字符串
//         std::vector<uint8_t> dataToSend;
//         std::string byteStr;
//         for (size_t i = 0; i < input.length(); i++)
//         {
//             if (isspace(input[i]))
//             {
//                 if (!byteStr.empty())
//                 {
//                     try
//                     {
//                         dataToSend.push_back(static_cast<uint8_t>(std::stoi(byteStr, nullptr, 16)));
//                         byteStr.clear();
//                     }
//                     catch (const std::exception &e)
//                     {
//                         std::cerr << "Invalid hex format: " << byteStr << std::endl;
//                         byteStr.clear();
//                     }
//                 }
//             }
//             else
//             {
//                 byteStr += input[i];
//             }
//         }

//         if (!byteStr.empty())
//         {
//             try
//             {
//                 dataToSend.push_back(static_cast<uint8_t>(std::stoi(byteStr, nullptr, 16)));
//             }
//             catch (const std::exception &e)
//             {
//                 std::cerr << "Invalid hex format: " << byteStr << std::endl;
//                 continue;
//             }
//         }

//         if (dataToSend.empty())
//         {
//             std::cerr << "No valid hex data entered" << std::endl;
//             continue;
//         }

//         std::cout << "Debug: Attempting to send data: ";
//         for (const auto &byte : dataToSend)
//         {
//             std::cout << std::hex << std::setw(2) << std::setfill('0')
//                       << static_cast<int>(byte) << " ";
//         }
//         std::cout << std::dec << std::endl;

//         int bytesSent = rs485.write(dataToSend.data(), dataToSend.size());
//         if (bytesSent < 0)
//         {
//             std::cerr << "Failed to send data: " << rs485.getLastError() << std::endl;
//         }
//         else
//         {
//             std::cout << "Successfully sent " << bytesSent << " bytes" << std::endl;

//             // 添加发送后的短暂延时，让接收端有时间处理数据
//             std::this_thread::sleep_for(std::chrono::milliseconds(100));
//         }
//     }

//     std::cout << "Shutting down..." << std::endl;
//     rs485.stopAsyncReceive();
//     rs485.close();
//     std::cout << "Program terminated" << std::endl;

//     return 0;
// }


// void test_thread()
// {
//     std::vector<uint16_t> dataToSend = {10};
//     std::vector<uint16_t> dataTorecv = {0};
//     while (1)
//     {
//         LOG(INFO) << "Debug: Attempting to read holding registers";
//         P_rtu_master->read_holding_register_single(1, 1, dataTorecv);
//         LOG(INFO) << "Debug: Read holding registers: " << dataTorecv[0];

//         std::this_thread::sleep_for(std::chrono::milliseconds(1000));

//         // 写入
//         LOG(INFO) << "Debug: Attempting to write holding registers";
//         P_rtu_master->write_holding_register_single(1, 1, dataToSend);
//         LOG(INFO) << "Debug: Write holding registers: " << dataToSend[0];
//         dataToSend[0]++;
//         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
//     }
// }

// int main()
// {
//     if(rs485_modbus_init() < 0 )
//     {
//         LOG(ERROR) << "Failed to initialize RS485 Modbus";
//         return -1;
//     }
//     LOG(INFO) << "RS485 Modbus initialized successfully";
//     std::thread t1(test_thread);
//     //等待键盘输入
//     std::cin.get();
//     t1.join();

//     return 0;
// }

// void test_thread2()
// {
//     std::vector<uint16_t> dataToSend = {10};
//     std::vector<uint16_t> dataTorecv = {0};
//     std::vector<uint16_t> dataToSend_mui = {10, 10, 10, 10, 10, 10};

//     while (1)
//     {
//         LOG(INFO) << "Debug: Attempting to read holding registers";
//         PP_rtu_master->read_holding_register_single(1, 1, dataTorecv);
//         LOG(INFO) << "Debug: Read holding registers: " << dataTorecv[0];

//         std::this_thread::sleep_for(std::chrono::milliseconds(100));

//         // 写入
//         LOG(INFO) << "Debug: Attempting to write holding registers";
//         PP_rtu_master->write_holding_register_single(1, 1, dataToSend);
//         LOG(INFO) << "Debug: Write holding registers: " << dataToSend[0];
//         dataToSend[0]++;
//         std::this_thread::sleep_for(std::chrono::milliseconds(100));

//         LOG(INFO) << "Debug: Attempting to write holding registers";
//         PP_rtu_master->write_holding_register_multiple(1, 2, dataToSend_mui);
//         for (auto &num : dataToSend_mui)
//         {
//             num += 1;
//         }
//         std::this_thread::sleep_for(std::chrono::milliseconds(100));
//     }
// }

// int main(int argc, char* argv[])
// {
//     if (rs485_modbus_init_v2() < 0)
//     {
//         LOG(ERROR) << "Failed to initialize RS485 Modbus";
//         return -1;
//     }
//     LOG(INFO) << "RS485 Modbus initialized successfully";

//     std::thread t1(test_thread2);

//     // 等待键盘输入
//     std::cin.get();
//     t1.join();

//     return 0;
// }

// void vit_hwt901_test_thread()
// {
//     vit_hwt901_data_t data_recv;

//     if(vit_hwt901_init() != YJ_OK)
//     {
//         LOG(ERROR) << "vit_hwt901_init failed";
//         return;
//     }
//     LOG(INFO) << "vit_hwt901_init success";
//     while (1)
//     {
//         vit_hwt901_read_all(&data_recv);
//         vit_hwt901_print_data(&data_recv);

//         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
//     }
// }

// int main(int argc, char *argv[])
// {
//     // std::thread t1(vit_hwt901_test_thread);

//     // // 等待键盘输入
//     // std::cin.get();
//     // t1.join();

//     // vit_hwt901_deinit();
//     return 0;
// }
